
package cn.xinfei.xdecision.data.core.frame.executors.sql;

import cn.xinfei.xdecision.common.model.datax.datamanage.v2.Variable;
import cn.xinfei.xdecision.common.model.datax.datasource.DataSource;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;

import java.math.BigDecimal;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SqlScriptHelper {




    private static final Logger LOGGER = LoggerFactory.getLogger(SqlScriptHelper.class);
//
//    /**
//     * 通过sql获取变量
//     *
//     * @param variable
//     * @return
//     */
//    private Object getVarValueBySql(Variable variable, Map<String, Object> inputParam) {
//        LOGGER.info("start【获取sql变量】, varCode:{}", variable.getFieldEn());
//        long start = System.currentTimeMillis();
//        DataSource dataSource = dataSourceService.getDataSourceByIdRunner(variable.getDataSourceId());
//        if (dataSource == null || dataSource.getStatus() == 0) {
//            return null;
//        }
//        DruidDataSource dynamicDataSource = null;
//        Jedis jedis = null;
//        boolean isDurid = false;
//        String keyMd5 = null;
//        Object resultValue = null;
//        Map<String, Object> parameterMap = new HashMap<>(); // 可以传入通用参数
//        //替换参数
//        this.getSqlFieldParam(variable, inputParam, parameterMap);
//        try {
//            switch (dataSource.getType()) {
//                case DataBaseReSource.MySql.type:
//                    dynamicDataSource = DataBaseReSource.MySql.getDataSource(dataSource);
//                    isDurid = true;
//                    break;
//                case DataBaseReSource.Oracle.type:
//                    dynamicDataSource = DataBaseReSource.Oracle.getDataSource(dataSource);
//                    isDurid = true;
//                    break;
//                case DataBaseReSource.Redis.type:
//                    String userName = dataSource.getUserName();
//                    if (StringUtils.isBlank(userName)) {
//                        userName = "root";
//                    }
//                    keyMd5 = CommonConst.JEDIS_KSESSION_KEY_PREFIX + MD5.GetMD5Code(dataSource.getHost() + ":" +
//                            dataSource.getPort() + ":" + dataSource.getDbName() + ":" + userName + ":" + dataSource.getPassword());
//                    jedis = DataBaseReSource.Redis.getDataSource(dataSource, keyMd5);
//                    break;
//            }
//
//            if (isDurid) {
//                // 创建动态数据源，并切换数据源
//                Map<Object, Object> dataSourceMap = DynamicDataSource.getInstance().getDataSourceMap();
//                String dataSourceKey = "dynamic-" + dataSource.getId();
//                dataSourceMap.put(dataSourceKey, dynamicDataSource);
//                DynamicDataSource.getInstance().setTargetDataSources(dataSourceMap);
//                DataSourceContextHolder.setDBType(dataSourceKey);
//                resultValue = handlerSqlFieldResult(variable, parameterMap);
//            } else if (jedis != null) {
//                resultValue = jedis.eval(parameterMap.get("sqlStr").toString());
//            }
//            if (resultValue == null) {
//                throw new ApiException(ErrorCodeEnum.GET_DATABASE_FIELD_ERROR.getCode(), ErrorCodeEnum.GET_DATABASE_FIELD_ERROR.getMessage());
//            }
//        } finally {
//            // 执行完成后切换到系统数据源
//            DataSourceContextHolder.setDBType("default");
//            if (StringUtils.isNotBlank(keyMd5) && jedis != null) {
//                redisKSessionPool.returnObject(keyMd5, jedis);
//            }
//        }
//        long end = System.currentTimeMillis();
//        fieldCallLogService.save(new FieldCallLog(variable.getId(), FieldTypeConsts.DATABASE,dataSource.getType(),dataSource.getId().longValue(), JSON.toJSONString(parameterMap),
//                JSON.toJSONString(resultValue),(end - start),variable.getOrganId()));
//        LOGGER.info("【获取数据库指标】varCode:{}, 耗时:{}, result:{}, parameterMap:{}", variable.getVarCode(), (end - start), resultValue, parameterMap);
//        return resultValue;
//
//    }
//
//    /**
//     * 匹配数据库指令中的占位符
//     */
//    private static Map getSqlFieldParam(Variable variable, Map<String, Object> inputParam, Map<String, Object> parameterMap) {
//        String sqlStr = variable.get();
//        // 添加动态参数
//        //处理in方法中的遍历
//        Pattern sqlInPattern = Pattern.compile("[\\s]*in[\\s]*\\([\\s]*#\\{([a-zA-Z0-9_\u4e00-\u9fa5()（）-]+)\\}[\\s]*\\)");
//        Matcher sqlInMatcher = sqlInPattern.matcher(sqlStr);
//        while (sqlInMatcher.find()) {
//            String replaceOld = sqlInMatcher.group(0);
//            String sqlField = sqlInMatcher.group(1);
//            String sqlVariable = variable.getSqlVariable();
//            String fieldEn = sqlField.split("\\.")[0];
//            String convertStr = "";
//            Object value = null;
//            if (StringUtils.isNotBlank(sqlVariable)) {
//                JSONArray sqlVariableArr = JSONArray.parseArray(sqlVariable);
//                for (int i = 0; i < sqlVariableArr.size(); i++) {
//                    JSONObject sqlVariableObj = sqlVariableArr.getJSONObject(i);
//                    if (sqlField.equals(sqlVariableObj.getString("key"))) {
//                        value = sqlVariableObj.getJSONArray("value");
//                    }
//                }
//            }
//            if (value == null) {
//                if (!inputParam.containsKey(fieldEn)) {
//                    //不存再需要重新获取
//                    List<String> fieldEns = new ArrayList<>();
//                    fieldEns.add(fieldEn);
//                    //查询未入参的en是否是指标库中的指标，如果是则u需要继续查找
//                    List<Variable> fieldList = fieldService.selectFieldListByEns(fieldEns);
//                    if (fieldList != null && !fieldList.isEmpty()) {
//                        //查询引用到的指标
//                        getEngineField(fieldList, inputParam);
//                    }
//
//                }
////                    value = inputParam.get(sqlField);
//                value = ExecuteUtils.getObjFromMap(inputParam, sqlField);
//            }
//            if (StringUtils.isBlank(convertStr) && value != null) {
//                if (value instanceof String) {
//                    convertStr = value.toString();
//                } else if (value instanceof List) {
//                    List collection = (List) value;
//                    int size = collection.size();
//
//                    for (int i = 0; i < size; i++) {
//                        convertStr += ("'" + String.valueOf(collection.get(i)) + "'");
//                        if (i < size - 1) {
//                            convertStr += ",";
//                        }
//                    }
//                }
//            }
//            sqlStr = sqlStr.replace(replaceOld, " in (" + convertStr + ") ");
//        }
//        Pattern pattern = Pattern.compile("#\\{[a-zA-Z0-9_\u4e00-\u9fa5()（）-]+\\}");
//        Matcher matcher = pattern.matcher(sqlStr);
//        while (matcher.find()) {
//            String sqlField = matcher.group(0).replace("#{", "").replace("}", "");
//            String fieldEn = sqlField.split("\\.")[0];
//            // sql动态参数从页面配置获取
//            String sqlVariable = variable.getSqlVariable();
//            if (StringUtils.isNotBlank(sqlVariable)) {
//                JSONArray sqlVariableArr = JSONArray.parseArray(sqlVariable);
//                for (int i = 0; i < sqlVariableArr.size(); i++) {
//                    JSONObject sqlVariableObj = sqlVariableArr.getJSONObject(i);
//                    if (sqlField.equals(sqlVariableObj.getString("key"))) {
//                        parameterMap.put(sqlField, sqlVariableObj.get("value"));
//                    }
//                }
//            }
//
//            // sql动态参数从变量池获取
//            if (!parameterMap.containsKey(fieldEn)) {
//                if (!inputParam.containsKey(fieldEn)) {
//                    //不存再需要重新获取
//                    List<String> fieldEns = new ArrayList<>();
//                    fieldEns.add(fieldEn);
//                    //查询未入参的en是否是指标库中的指标，如果是则u需要继续查找
//                    List<Variable> fieldList = fieldService.selectFieldListByEns(fieldEns);
//                    if (fieldList != null && !fieldList.isEmpty()) {
//                        //查询引用到的指标
//                        getEngineField(fieldList, inputParam);
//                    }
//
//                }
//                parameterMap.put(sqlField, ExecuteUtils.getObjFromMap(inputParam, sqlField));
//            }
//        }
//        Pattern pattern$ = Pattern.compile("\\$\\{[a-zA-Z0-9_\u4e00-\u9fa5()（）-]+\\}");
//        Matcher matcher$ = pattern$.matcher(sqlStr);
//        while (matcher$.find()) {
//            String sqlField = matcher$.group(0).replace("${", "").replace("}", "");
//            String fieldEn = sqlField.split("\\.")[0];
//            // sql绑定参数从页面配置获取
//            String sqlVariable = variable.getSqlVariable();
//            String dictVariable = variable.getDictVariable();
//            String replaceStr = "";
//            if (StringUtils.isNotBlank(sqlVariable)) {
//                JSONArray sqlVariableArr = JSONArray.parseArray(sqlVariable);
//                for (int i = 0; i < sqlVariableArr.size(); i++) {
//                    JSONObject sqlVariableObj = sqlVariableArr.getJSONObject(i);
//
//                    if (!sqlField.equals(sqlVariableObj.getString("key"))) {
//                        continue;
//                    }
//                    if (inputParam.containsKey(fieldEn)) {
//                        replaceStr = ExecuteUtils.getObjFromMap(inputParam, sqlField).toString();
//                    } else if (sqlVariableObj.get("value") != null) {
//                        replaceStr = String.valueOf(sqlVariableObj.get("value"));
//                    }
//                    if (StringUtils.isNotBlank(replaceStr)) {
//                        break;
//                    }
//
//                }
//            }
//            if (StringUtils.isNotBlank(dictVariable)) {
//                JSONArray jsonArray = JSONArray.parseArray(dictVariable);
//                for (int i = 0; i < jsonArray.size(); i++) {
//                    JSONObject jsonObject = jsonArray.getJSONObject(i);
//                    if (!sqlField.equals(jsonObject.getString("key"))) {
//                        continue;
//                    }
////                    if (inputParam.containsKey(fieldEn)) {
////                        replaceStr = ExecuteUtils.getObjFromMap(inputParam, sqlField).toString();
////                    } else
////                    if (jsonObject.get("value") != null) {
////                        switch (jsonObject.getString("type")){
////                            case "date":
////                                try {
////                                    replaceStr = DateUtil.format(new Date(),jsonObject.getString("value"));
////                                }catch (Exception e){
////                                    e.printStackTrace();
////                                    replaceStr = DateUtil.format(new Date(),"yyyyMMdd");
////                                }
////                                break;
////                            default:
////                                replaceStr = String.valueOf(jsonObject.get("value"));
////                        }
////                    }
//                    replaceStr = DictVariableUtils.getValueFromJsonObject(jsonObject).toString();
//                    if (StringUtils.isNotBlank(replaceStr)) {
//                        break;
//                    }
//                }
//            }
//            if (StringUtils.isNotBlank(replaceStr)) {
//                //已经取出则直接跳过
//                sqlStr = sqlStr.replace("${" + sqlField + "}", replaceStr);
//                continue;
//            }
//            // sql动态参数从变量池获取
//            if (!parameterMap.containsKey(fieldEn)) {
//                if (!inputParam.containsKey(fieldEn)) {
//                    //不存再需要重新获取
//                    //查询未入参的en是否是指标库中的指标，如果是则u需要继续查找
//                    List<Variable> fieldList = fieldService.selectFieldListByEns(Arrays.asList(fieldEn));
//                    if (fieldList != null && !fieldList.isEmpty()) {
//                        //查询引用到的指标
//                        getEngineField(fieldList, inputParam);
//                    }
//                }
//                replaceStr = ExecuteUtils.getObjFromMap(inputParam, sqlField).toString();
//            }
//            if (StringUtils.isNotBlank(replaceStr)) {
//                sqlStr = sqlStr.replace("${" + sqlField + "}", replaceStr);
//                break;
//            }
//        }
//        parameterMap.put("sqlStr", sqlStr);
//        return parameterMap;
//    }
//
//
//
//    /**
//     * 调用第三方数据库执行sql获取结果
//     */
//    private Object handleSqlVarResult(Variable field, Map<String, Object> parameterMap) {
//        List<LinkedHashMap<String, Object>> result = simpleMapper.customSelect(parameterMap);
//        Object resultValue = null;
//        if (result == null || result.size() == 0) {
//            resultValue = null;
//        } else {
//            //json类型的数据
//            if (field.getValueType() == 6) {
//                String json = field.getJsonValue();
//                //示例数据为数组
//                if (StringUtils.isNotBlank(json) && json.startsWith("[") && json.endsWith("]")) {
//                    resultValue = result;
//                } else {
//                    resultValue = result.get(0);
//                }
//            } else if (result.size() == 1) {// 基本指标只能是一个值。所以只能取sql查出来的第一个值。否则抛出异常
//                LinkedHashMap<String, Object> resultMap = result.get(0);
//                if (resultMap.size() == 1) {
//                    for (Map.Entry<String, Object> entry : resultMap.entrySet()) {
//                        Object value = entry.getValue();
//
//                        // 防止double表示为科学计数法
//                        if (value instanceof Double) {
//                            value = BigDecimal.valueOf((Double) value);
//                        }
//                        resultValue = value.toString();
//                    }
//                } else {
//                    throw new RuntimeException("sql变量计算异常，sql字段个数超出预期。查询结果resultMap:" + resultMap.toString());
//                }
//            } else {
//                throw new RuntimeException("sql变量计算异常，sql结果个数超出预期。查询结果result:" + result.toString());
//            }
//        }
//        return resultValue;
//    }
}
